પાયથન કોરૂટીન ડિબગીંગ: Asyncio ડિબગ મોડમાં માસ્ટરી મેળવો

આ ચેતવણીઓ તમને સંસાધન લીક્સને ઓળખવામાં અને ઠીક કરવામાં મદદ કરે છે, જેનાથી કામગીરીમાં ઘટાડો અને સિસ્ટમ અસ્થિરતા આવી શકે છે.

4. ધીમી કોલબેક શોધ

ડિબગ મોડ એક્ઝિક્યુટ થવામાં નિર્દિષ્ટ થ્રેશોલ્ડ કરતાં વધુ સમય લેતી કોલબેક્સને શોધી શકે છે. આ તમને કામગીરીની બોટલનેક્સને ઓળખવામાં મદદ કરે છે:

            asyncio | Task was destroyed but it is pending!
pending time: 12345.678 ms

            

              
                Copy
              
            
          

5. અપવાદ હેન્ડલિંગ

ડિબગ મોડ કોરૂટીન્સમાં ઉભા થયેલા અપવાદોને વધુ સંદર્ભ આપે છે, જેમાં ટાસ્ક અને કોરૂટીનનો સમાવેશ થાય છે જ્યાં અપવાદ આવ્યો હતો:

            asyncio | Task exception was never retrieved
future: () done, raised ValueError('Invalid value')>
            

              
                Copy
              
            
          

આ આઉટપુટ સૂચવે છે કે Task-1 માં ValueError ઉભો થયો હતો અને તેને યોગ્ય રીતે હેન્ડલ કરવામાં આવ્યો ન હતો.

Asyncio ડિબગ મોડ સાથે ડિબગીંગના વ્યવહારિક ઉદાહરણો

ચાલો કેટલાક વ્યવહારિક ઉદાહરણો જોઈએ કે સામાન્ય સમસ્યાઓનું નિદાન કરવા માટે asyncio ડિબગ મોડનો ઉપયોગ કેવી રીતે કરવો:

1. અનક્લોઝ્ડ સોકેટ્સ શોધવા

નીચેના કોડને ધ્યાનમાં લો જે સોકેટ બનાવે છે પરંતુ તેને યોગ્ય રીતે બંધ કરતું નથી:

            import asyncio
import socket

async def handle_client(reader, writer):
    data = await reader.read(100)
    message = data.decode()
    addr = writer.get_extra_info('peername')
    print(f"Received {message!r} from {addr!r}")

    print(f"Send: {message!r}")
    writer.write(data)
    await writer.drain()

    # Missing: writer.close()

async def main():
    server = await asyncio.start_server(
        handle_client,
        '127.0.0.1',
        8888
    )

    addr = server.sockets[0].getsockname()
    print(f'Serving on {addr}')

    async with server:
        await server.serve_forever()

if __name__ == "__main__":
    asyncio.run(main(), debug=True)
            

              
                Copy
              
            
          

જ્યારે તમે ડિબગ મોડ સક્ષમ કરીને આ કોડ ચલાવો છો, ત્યારે તમને અનક્લોઝ્ડ સોકેટ સૂચવતી ResourceWarning દેખાશે:

            ResourceWarning: unclosed 
            

              
                Copy
              
            
          

આને ઠીક કરવા માટે, તમારે ખાતરી કરવાની જરૂર છે કે સોકેટ યોગ્ય રીતે બંધ છે, ઉદાહરણ તરીકે, handle_client કોરૂટીનમાં writer.close() ઉમેરીને અને તેની રાહ જોઈને:

                writer.close()
    await writer.wait_closed()
            

              
                Copy
              
            
          

2. ધીમી કોલબેક્સને ઓળખવી

ધારો કે તમારી પાસે એક કોરૂટીન છે જે ધીમી કામગીરી કરે છે:

            import asyncio
import time

async def slow_function():
    print("Starting slow function")
    time.sleep(2)
    print("Slow function finished")
    return "Result"

async def main():
    task = asyncio.create_task(slow_function())
    result = await task
    print(f"Result: {result}")

if __name__ == "__main__":
    asyncio.run(main(), debug=True)
            

              
                Copy
              
            
          

જ્યારે ડિફોલ્ટ ડિબગ આઉટપુટ સીધી રીતે ધીમી કોલબેક્સને પિનપોઇન્ટ કરતું નથી, ત્યારે તેને કાળજીપૂર્વક લોગીંગ અને પ્રોફાઈલિંગ ટૂલ્સ (જેમ કે cProfile અથવા py-spy) સાથે જોડીને તમે તમારા કોડના ધીમા ભાગોને સંકુચિત કરી શકો છો. સંભવિત રૂપે ધીમી કામગીરી પહેલાં અને પછી ટાઇમસ્ટેમ્પ્સ લોગ કરવાનું વિચારો. પછી cProfile જેવા ટૂલ્સનો ઉપયોગ લોગ કરેલા ફંક્શન કૉલ્સ પર બોટલનેક્સને અલગ કરવા માટે કરી શકાય છે.

3. ટાસ્ક કેન્સલેશનને ડિબગ કરવું

એક એવો દૃશ્ય ધ્યાનમાં લો જ્યાં ટાસ્ક અણધારી રીતે રદ કરવામાં આવે છે:

            import asyncio

async def worker():
    try:
        while True:
            print("Working...")
            await asyncio.sleep(0.5)
    except asyncio.CancelledError:
        print("Worker cancelled")

async def main():
    task = asyncio.create_task(worker())
    await asyncio.sleep(2)
    task.cancel()
    try:
        await task
    except asyncio.CancelledError:
        print("Task cancelled in main")

if __name__ == "__main__":
    asyncio.run(main(), debug=True)
            

              
                Copy
              
            
          

ડિબગ આઉટપુટ ટાસ્ક રદ કરવામાં આવી રહ્યું હોવાનું બતાવશે:

            asyncio | execute  started at example.py:16>
Working...
Working...
Working...
Working...
asyncio | Task-1: cancelling
Worker cancelled
asyncio | Task-1: cancelled by  result=None>
Task cancelled in main
            

              
                Copy
              
            
          

આ પુષ્ટિ કરે છે કે ટાસ્ક main() કોરૂટીન દ્વારા રદ કરવામાં આવ્યો હતો. except asyncio.CancelledError બ્લોક ટાસ્ક સંપૂર્ણપણે સમાપ્ત થાય તે પહેલાં સફાઈ માટે પરવાનગી આપે છે, સંસાધન લીક્સ અથવા અસંગત સ્થિતિને અટકાવે છે.

4. કોરૂટીન્સમાં અપવાદોનું સંચાલન કરવું

અસિંક્રોનસ કોડમાં યોગ્ય અપવાદ હેન્ડલિંગ નિર્ણાયક છે. અનહેન્ડલ્ડ અપવાદ સાથે નીચેનું ઉદાહરણ ધ્યાનમાં લો:

            import asyncio

async def divide(x, y):
    return x / y

async def main():
    result = await divide(10, 0)
    print(f"Result: {result}")

if __name__ == "__main__":
    asyncio.run(main(), debug=True)
            

              
                Copy
              
            
          

ડિબગ મોડ અનહેન્ડલ્ડ અપવાદની જાણ કરશે:

            asyncio | Task exception was never retrieved
future:  result=None, exception=ZeroDivisionError('division by zero')>
            

              
                Copy
              
            
          

આ અપવાદને હેન્ડલ કરવા માટે, તમે try...except બ્લોકનો ઉપયોગ કરી શકો છો:

            import asyncio

async def divide(x, y):
    return x / y

async def main():
    try:
        result = await divide(10, 0)
        print(f"Result: {result}")
    except ZeroDivisionError as e:
        print(f"Error: {e}")

if __name__ == "__main__":
    asyncio.run(main(), debug=True)
            

              
                Copy
              
            
          

હવે, અપવાદ પકડવામાં આવશે અને ગ્રેસફુલી હેન્ડલ કરવામાં આવશે.

Asyncio ડિબગીંગ માટે શ્રેષ્ઠ પ્રથાઓ

asyncio કોડને ડિબગ કરવા માટે અહીં કેટલીક શ્રેષ્ઠ પ્રથાઓ છે:

• ડિબગ મોડને સક્ષમ કરો: વિકાસ અને પરીક્ષણ દરમિયાન હંમેશા ડિબગ મોડને સક્ષમ કરો.
• લોગીંગનો ઉપયોગ કરો: તમારા કોરૂટીન્સના એક્ઝેક્યુશન ફ્લોને ટ્રેક કરવા માટે વિગતવાર લોગીંગ ઉમેરો. asyncio વિશિષ્ટ ઇવેન્ટ્સ માટે logging.getLogger('asyncio') અને એપ્લિકેશન-વિશિષ્ટ ડેટા માટે તમારા પોતાના લોગર્સનો ઉપયોગ કરો.
• અપવાદોને હેન્ડલ કરો: તમારી એપ્લિકેશનને ક્રેશ થવાથી બચાવવા માટે મજબૂત અપવાદ હેન્ડલિંગ લાગુ કરો.
• ટાસ્ક જૂથોનો ઉપયોગ કરો (Python 3.11+): ટાસ્ક જૂથો સંબંધિત ટાસ્કના જૂથોમાં અપવાદ હેન્ડલિંગ અને કેન્સલેશનને સરળ બનાવે છે.
• તમારા કોડને પ્રોફાઇલ કરો: કામગીરીની બોટલનેક્સને ઓળખવા માટે પ્રોફાઇલિંગ ટૂલ્સનો ઉપયોગ કરો.
• એકમ પરીક્ષણો લખો: તમારા કોરૂટીન્સના વર્તનને ચકાસવા માટે સંપૂર્ણ એકમ પરીક્ષણો લખો.
• પ્રકાર સંકેતોનો ઉપયોગ કરો: પ્રારંભિક તબક્કામાં પ્રકાર-સંબંધિત ભૂલોને પકડવા માટે પ્રકાર સંકેતોનો લાભ લો.
• ડિબગરનો ઉપયોગ કરવાનું વિચારો: pdb અથવા IDE ડિબગર્સ જેવા ટૂલ્સનો ઉપયોગ asyncio કોડ દ્વારા સ્ટેપ કરવા માટે થઈ શકે છે. જો કે, અસિંક્રોનસ એક્ઝેક્યુશનની પ્રકૃતિને કારણે તેઓ કાળજીપૂર્વક લોગીંગ સાથે ડિબગ મોડ કરતાં ઘણીવાર ઓછા અસરકારક હોય છે.

અદ્યતન ડિબગીંગ તકનીકો

મૂળભૂત ડિબગ મોડથી આગળ, આ અદ્યતન તકનીકોનો વિચાર કરો:

1. કસ્ટમ ઇવેન્ટ લૂપ નીતિઓ

ઇવેન્ટ્સને અટકાવવા અને લોગ કરવા માટે તમે કસ્ટમ ઇવેન્ટ લૂપ નીતિઓ બનાવી શકો છો. આ તમને ડિબગીંગ પ્રક્રિયા પર વધુ ઝીણવટભર્યું નિયંત્રણ મેળવવાની મંજૂરી આપે છે.

2. થર્ડ-પાર્ટી ડિબગીંગ ટૂલ્સનો ઉપયોગ કરવો

કેટલાક થર્ડ-પાર્ટી ડિબગીંગ ટૂલ્સ તમને asyncio કોડને ડિબગ કરવામાં મદદ કરી શકે છે, જેમ કે:

• PySnooper: એક શક્તિશાળી ડિબગીંગ ટૂલ જે તમારા કોડના અમલને આપમેળે લોગ કરે છે.
• pdb++: ઉન્નત સુવિધાઓ સાથે સ્ટાન્ડર્ડ pdb ડિબગરનું એક સુધારેલું સંસ્કરણ.
• asyncio_inspector: asyncio ઇવેન્ટ લૂપ્સનું નિરીક્ષણ કરવા માટે ખાસ રચાયેલ લાઇબ્રેરી.

3. મંકી પેચિંગ (સાવધાનીથી ઉપયોગ કરો)

આત્યંતિક કિસ્સાઓમાં, તમે ડિબગીંગ હેતુઓ માટે asyncio ફંક્શન્સના વર્તનને સંશોધિત કરવા માટે મંકી પેચિંગનો ઉપયોગ કરી શકો છો. જો કે, આ સાવધાનીથી કરવું જોઈએ, કારણ કે તે સૂક્ષ્મ ભૂલો રજૂ કરી શકે છે અને તમારા કોડને જાળવવાનું મુશ્કેલ બનાવી શકે છે. આ સામાન્ય રીતે નિરપેક્ષપણે જરૂરી ન હોય ત્યાં સુધી નિરુત્સાહિત કરવામાં આવે છે.

નિષ્કર્ષ

અસિંક્રોનસ કોડને ડિબગ કરવું પડકારરૂપ હોઈ શકે છે, પરંતુ asyncio ડિબગ મોડ પ્રક્રિયાને સરળ બનાવવા માટે મૂલ્યવાન સાધનો અને આંતરદૃષ્ટિ પ્રદાન કરે છે. ડિબગ મોડને સક્ષમ કરીને, આઉટપુટનું અર્થઘટન કરીને અને શ્રેષ્ઠ પ્રથાઓને અનુસરીને, તમે તમારા અસિંક્રોનસ એપ્લિકેશન્સમાં સામાન્ય સમસ્યાઓને અસરકારક રીતે ઓળખી અને ઉકેલી શકો છો, જે વધુ મજબૂત અને કાર્યક્ષમ કોડ તરફ દોરી જાય છે. શ્રેષ્ઠ પરિણામો માટે લોગીંગ, પ્રોફાઈલિંગ અને સંપૂર્ણ પરીક્ષણ સાથે ડિબગ મોડને જોડવાનું યાદ રાખો. પ્રેક્ટિસ અને યોગ્ય સાધનોથી, તમે asyncio કોરૂટીન્સને ડિબગ કરવાની કળામાં માસ્ટરી મેળવી શકો છો અને સ્કેલેબલ, કાર્યક્ષમ અને વિશ્વસનીય અસિંક્રોનસ એપ્લિકેશન્સ બનાવી શકો છો.